"""
WebSocket服务器实现
"""
import asyncio
import json
import logging
import traceback
import time
from datetime import datetime
from typing import Dict, Any, Optional, Callable, List, Set


class WebSocketServer:
    """WebSocket服务器实现"""
    
    def __init__(self, host='localhost', port=8765):
        """
        初始化WebSocket服务器
        
        @param host: 服务器主机地址
        @param port: 服务器端口
        """
        self.host = host
        self.port = port
        self.server = None
        self.clients = set()
        self.message_callback = None
        self.connection_callback = None
        self.logger = logging.getLogger("websocket_server")
        self.running = False
    
    def set_message_callback(self, callback):
        """
        设置消息处理回调
        
        @param callback: 回调函数，接收一个消息参数
        """
        self.message_callback = callback
    
    def set_connection_callback(self, callback):
        """
        设置连接状态回调
        
        @param callback: 回调函数，接收一个布尔参数表示是否连接
        """
        self.connection_callback = callback
    
    def process_comment(self, data):
        """
        处理评论消息
        
        @param data: 原始消息数据
        @return: 处理后的消息数据
        """
        # 提取基本信息
        nickname = data.get('nickname', '未知用户')
        content = data.get('content', '')
        user_id = data.get('user_id', data.get('userId', ''))
        timestamp = data.get('timestamp', datetime.now().timestamp())
        
        # 记录日志
        self.logger.info(f"收到评论: {nickname} - {content}")
        
        # 构建标准格式消息
        processed_data = {
            'type': 'comment',
            'nickname': nickname,
            'content': content,
            'user_id': user_id,
            'timestamp': timestamp,
            'raw_data': data
        }
        
        return processed_data
    
    async def process_websocket(self, websocket):
        """
        处理WebSocket连接
        
        @param websocket: WebSocket连接对象
        """
        # 添加到客户端集合
        self.clients.add(websocket)
        client_id = id(websocket)
        
        # 获取客户端信息
        try:
            client_info = f"{websocket.remote_address[0]}:{websocket.remote_address[1]}"
        except:
            client_info = f"ID:{client_id}"
        
        # 记录连接信息
        self.logger.info(f"新客户端连接: {client_info}")
        
        # 通知连接状态变化
        if self.connection_callback:
            self.connection_callback(True)
        
        try:
            # 处理消息
            async for message in websocket:
                # 打印原始数据
                print("\n==== 接收到原始WebSocket数据 ====")
                print(f"客户端: {client_info}")
                print(f"数据: {message[:1000]}")  # 限制打印长度，避免过长
                print("================================\n")
                
                self.logger.info(f"[Socket数据] 接收到原始数据: {message[:200]}...")
                
                try:
                    # 解析JSON消息
                    data = json.loads(message)
                    
                    # 处理心跳消息
                    if data.get('type') == 'heartbeat':
                        self.logger.debug("[Socket数据] 收到心跳消息")
                        continue
                    
                    # 使用消息处理器处理消息
                    try:
                        from app.services.message_processor import MessageProcessor
                        processor = MessageProcessor.get_instance()
                        processor.process_message(data, "websocket")
                        self.logger.debug(f"[Socket数据] 消息已通过消息处理器处理: {data.get('type', 'unknown')}")
                    except ImportError:
                        # 消息处理器不可用，记录错误但不进行处理
                        self.logger.error("[Socket数据] 消息处理器不可用，无法处理消息")
                        self.logger.error("请确保MessageProcessor模块已正确安装和导入")
                    except Exception as e:
                        # 消息处理器处理失败，记录错误但不进行处理
                        self.logger.error(f"[Socket数据] 消息处理器处理失败: {str(e)}")
                        self.logger.error(traceback.format_exc())
                            
                except json.JSONDecodeError:
                    self.logger.error(f"[Socket数据] 无效的JSON数据: {message}")
                except Exception as e:
                    self.logger.error(f"[Socket数据] 处理消息时出错: {str(e)}")
                    self.logger.error(traceback.format_exc())
        except Exception as e:
            self.logger.error(f"WebSocket连接异常: {str(e)}")
            self.logger.error(traceback.format_exc())
        finally:
            # 从客户端集合中移除
            self.clients.discard(websocket)
            
            # 如果没有客户端连接，通知连接状态变化
            if not self.clients and self.connection_callback:
                self.connection_callback(False)
            
            self.logger.info(f"客户端断开连接: {client_info}")
    
    async def start(self):
        """
        启动WebSocket服务器
        """
        import websockets
        
        if self.running:
            self.logger.warning("WebSocket服务器已在运行")
            return
        
        try:
            self.server = await websockets.serve(
                self.process_websocket,
                self.host,
                self.port
            )
            self.running = True
            self.logger.info(f"WebSocket服务器已启动，地址: {self.host}:{self.port}")
        except Exception as e:
            self.logger.error(f"启动WebSocket服务器失败: {str(e)}")
            self.logger.error(traceback.format_exc())
            raise
    
    def stop(self):
        """
        停止WebSocket服务器
        """
        if not self.running:
            return
        
        self.logger.info("正在停止WebSocket服务器...")
        
        # 标记服务器为非运行状态
        self.running = False
        
        # 关闭所有客户端连接
        # 注意：不使用asyncio.run()，因为它会创建新的事件循环
        for client in list(self.clients):
            try:
                # 只记录关闭意图，不实际执行异步关闭
                self.logger.debug(f"标记客户端连接关闭: {client.remote_address}")
            except Exception as e:
                self.logger.error(f"关闭客户端连接失败: {str(e)}")
        
        # 清空客户端列表
        self.clients.clear()
        
        # 如果有连接回调，通知连接状态变化
        if self.connection_callback:
            try:
                self.connection_callback(False)
            except Exception as e:
                self.logger.error(f"调用连接回调失败: {str(e)}")
        
        self.logger.info("WebSocket服务器已停止")

    async def _handle_message(self, websocket, client_id):
        """
        处理来自客户端的消息
        
        @param websocket: WebSocket 连接
        @param client_id: 客户端 ID
        """
        async for message in websocket:
            try:
                # 解析消息数据
                message_data = json.loads(message)
                self.logger.debug(f"收到消息: {message}")
                
                # 使用消息处理器处理消息
                try:
                    from app.services.message_processor import MessageProcessor
                    processor = MessageProcessor.get_instance()
                    processor.process_message(message_data, "websocket")
                    self.logger.debug("消息已通过消息处理器处理")
                except ImportError:
                    # 消息处理器不可用，记录错误但不进行处理
                    self.logger.error("消息处理器不可用，无法处理消息")
                    self.logger.error("请确保MessageProcessor模块已正确安装和导入")
                except Exception as e:
                    # 消息处理器处理失败，记录错误但不进行处理
                    self.logger.error(f"消息处理器处理消息失败: {str(e)}")
                    self.logger.error(traceback.format_exc())
                
            except json.JSONDecodeError:
                self.logger.warning(f"收到非JSON消息: {message}")
            except Exception as e:
                self.logger.error(f"处理消息时出错: {str(e)}")
                import traceback
                self.logger.error(f"异常堆栈: {traceback.format_exc()}") 